// Удаляем использование IntentUnit
uses
  SysUtils, Classes, PostProcessor, Unix, BaseUnix,
  Transformer, MatrixOps, TextEmbeddings,LazUTF8, ucs4unit,
  ucs4opunit, ucs4functionsunit, TextDecoder, Word2Vec,DataUtils,Math,TrainerUnit,DateUtils, DataAugmentation, HyperparameterOptimizer;

// Удаляем тип TIntentType и связанные функции
function FindBestResponse(const question: ucs4): string;
var
  i, j: Integer;
  questionStr, pattern, context: string;
  scores: array of Double;
  maxScore: Double;
  bestIndex: Integer;
  foundDirectMatch: Boolean;
begin
  questionStr := UTF8LowerCase(question.ToUTF8);
  questionStr := questionStr.Trim;
  WriteLn('Debug: Анализируем вопрос: "', questionStr, '"');

  // Получаем контекст диалога
  context := GetConversationContext;

  WriteLn('Debug: Контекст: ', context);

  // Проверяем продолжение диалога
  if context.Contains('как дела') and questionStr.Contains('норм') then
  begin
    Result := 'Рад слышать! Чем еще могу помочь?';
    Exit;
  end;
  
  if context.Contains('погод') and questionStr.Contains('солн') then
  begin
    Result := 'Солнечная погода - это прекрасно! Хотите обсудить планы на день?';
    Exit;
  end;
  
  // Сначала проверяем прямые совпадения
  foundDirectMatch := False;
  for i := 0 to High(ResponseTemplates) do
  begin
    for j := 0 to High(ResponseTemplates[i].Patterns) do
    begin
      pattern := UTF8LowerCase(ResponseTemplates[i].Patterns[j]);
      
      // Прямое вхождение или очень похожая фраза
      if (questionStr = pattern) or 
         (Pos(pattern, questionStr) > 0) or
         (questionStr.Contains(pattern)) then
      begin
        WriteLn('Debug: Прямое совпадение с шаблоном: ', pattern);
        Result := ResponseTemplates[i].Response;
        Exit;
      end;
    end;
  end;
  
  // Если нет прямых совпадений, используем Word2Vec
  if (WordEmbeddings <> nil) and (questionStr <> '') then
  begin
    SetLength(scores, Length(ResponseTemplates));
    maxScore := 0;
    bestIndex := -1;
    
    for i := 0 to High(ResponseTemplates) do
    begin
      scores[i] := 0;
      for j := 0 to High(ResponseTemplates[i].Patterns) do
      begin
        try
          pattern := UTF8LowerCase(ResponseTemplates[i].Patterns[j]);
          scores[i] := Max(scores[i], WordEmbeddings.FastSimilarity(questionStr, pattern));
        except
          scores[i] := 0;
        end;
      end;
      
      if scores[i] > maxScore then
      begin
        maxScore := scores[i];
        bestIndex := i;
      end;
    end;
    
    if (bestIndex >= 0) and (maxScore > 0.4) then // Понижаем порог
    begin
      WriteLn('Debug: Найден шаблонный ответ [', 
        ResponseTemplates[bestIndex].Patterns[0], 
        '] score=', maxScore:0:2);
      Result := ResponseTemplates[bestIndex].Response;
      Exit;
    end;
  end;
  
  // Если ничего не найдено
  WriteLn('Debug: Шаблон не найден');
  Result := '';
end;

procedure ProcessUserInput;
var
  inputText: ucs4;
  response, userMessage: string;
  filesList: TStringList;
begin
  filesList := TStringList.Create;
  try
    UserInput := GetUserInput(POST_FILE, filesList);
    inputText := UserInput.Message;
    userMessage := inputText.ToUTF8;
    LastUserMessage := userMessage; // Сохраняем последнее сообщение
    
    if inputText.Length = 0 then Exit;

    response := FindBestResponse(inputText);
    
    if response = '' then
    begin
      response := GenerateContextAwareResponse(inputText);
    end;
    
    LastAIResponse := response; // Сохраняем последний ответ
    
    // Обновляем контекст
    UpdateConversationContext(userMessage, response);
    
    WriteLn('Ответ AI:');
    WriteLn(response);

    // Вызывать после каждого успешного ответа
    LearnFromConversation(userMessage, response);
    
    // Предлагаем обратную связь
    if not response.Contains('Здравствуйте') and 
       not response.Contains('погод') and
       (Length(response) > 10) then
    begin
      InteractiveLearning(TransformerModel);
    end
    
  finally
    filesList.Free;
  end;
end;

function AddPositionalEncoding(const input, posEnc: TDoubleMatrix): TDoubleMatrix;
var
  i, j: Integer;
begin
  // Проверяем совпадение размерностей
  if (Length(input) > Length(posEnc)) then
  begin
    WriteLn('Предупреждение AddPositionalEncoding: Входная последовательность длиннее позиционного кодирования');
    WriteLn('  input: ', Length(input), 'x', Length(input[0]));
    WriteLn('  posEnc: ', Length(posEnc), 'x', Length(posEnc[0]));
    
    // Создаем расширенное позиционное кодирование если нужно
    SetLength(Result, Length(input), Length(input[0]));
    for i := 0 to High(input) do
    begin
      for j := 0 to High(input[0]) do
      begin
        if i < Length(posEnc) then
          Result[i][j] := input[i][j] + posEnc[i][j]
        else
          Result[i][j] := input[i][j]; // Для позиций beyond maxLen используем только вход
      end;
    end;
    Exit;
  end;
  
  if (Length(input) <> Length(posEnc)) or (Length(input[0]) <> Length(posEnc[0])) then
  begin
    WriteLn('ОШИБКА AddPositionalEncoding: Несовпадение размеров');
    WriteLn('  input: ', Length(input), 'x', Length(input[0]));
    WriteLn('  posEnc: ', Length(posEnc), 'x', Length(posEnc[0]));
    // Возвращаем input без изменений
    Result := CopyMatrix(input);
    Exit;
  end;
  
  Result := MatrixAdd(input, posEnc);
end;

procedure Initialize;
var
  defaultConfig: TTransformerConfig;
  TrainingData: TTrainingDataset;
begin
  // ... существующий код ...
  
  // Создаем финальную конфигурацию
  with FinalConfig do
  begin
    InputSize := 300;
    NumLayers := BestConfig.NumLayers;
    NumHeads := BestConfig.NumHeads;
    FFNDim := BestConfig.FFNDim;
    MaxSeqLength := 500; // Увеличиваем с 100 до 500
    DropoutRate := BestConfig.DropoutRate;
    WeightDecay := BestConfig.WeightDecay;
    GradientClipValue := 1.0;
    UseLayerNorm := True;
  end;
  
  // ... остальной код ...
end;

// В файле Transformer.pas в процедуре ForwardTransformer:
// Закомментируй эту строку:
// x := AddPositionalEncoding(x, model.PosEncoding);

// И добавь вместо нее:
x := CopyMatrix(x); // Просто копируем без позиционного кодирования
WriteLn('  Позиционное кодирование временно отключено');

x := AddPositionalEncoding(x, model.PosEncoding);

// Временно отключаем позиционное кодирование
WriteLn('  Пропускаем позиционное кодирование для отладки');
// x := AddPositionalEncoding(x, model.PosEncoding);
x := CopyMatrix(x); // Просто копируем матрицу

with FinalConfig do
begin
  InputSize := 300;
  NumLayers := BestConfig.NumLayers;
  NumHeads := BestConfig.NumHeads;
  FFNDim := BestConfig.FFNDim;
  MaxSeqLength := 1000; // Увеличиваем до 1000
  DropoutRate := BestConfig.DropoutRate;
  WeightDecay := BestConfig.WeightDecay;
  GradientClipValue := 1.0;
  UseLayerNorm := True;
end;

function AddPositionalEncoding(const input, posEnc: TDoubleMatrix): TDoubleMatrix;
var
  i, j: Integer;
begin
  // Проверяем совпадение размерностей по столбцам (embedding size)
  if Length(input[0]) <> Length(posEnc[0]) then
  begin
    WriteLn('ОШИБКА AddPositionalEncoding: Несовпадение embedding size');
    WriteLn('  input cols: ', Length(input[0]));
    WriteLn('  posEnc cols: ', Length(posEnc[0]));
    Result := CopyMatrix(input);
    Exit;
  end;
  
  SetLength(Result, Length(input), Length(input[0]));
  
  for i := 0 to High(input) do
  begin
    for j := 0 to High(input[0]) do
    begin
      if i < Length(posEnc) then
        Result[i][j] := input[i][j] + posEnc[i][j]
      else
        Result[i][j] := input[i][j]; // Для последовательностей длиннее maxLen
    end;
  end;
end;

function AddPositionalEncoding(const input, posEnc: TDoubleMatrix): TDoubleMatrix;
var
  i, j: Integer;
begin
  // Для батча из отдельных примеров (не последовательностей) 
  // позиционное кодирование не нужно
  if Length(input) <> Length(posEnc) then
  begin
    WriteLn('Пропускаем позиционное кодирование для батча примеров');
    Result := CopyMatrix(input);
    Exit;
  end;
  
  // Стандартная обработка для последовательностей
  SetLength(Result, Length(input), Length(input[0]));
  for i := 0 to High(input) do
    for j := 0 to High(input[0]) do
      Result[i][j] := input[i][j] + posEnc[i][j];
end;

function TextsToMatrix(const texts: TUC4Array; embeddingSize: Integer): TDoubleMatrix;
var
  i, tokenCount, maxTokens: Integer;
  tokens: TUC4Array;
  tokenEmbeddings: TDoubleMatrix;
begin
  // Находим максимальное количество токенов
  maxTokens := 0;
  for i := 0 to High(texts) do
  begin
    tokens := TokenizeForNLP(texts[i]);
    maxTokens := Max(maxTokens, Length(tokens));
  end;

  SetLength(Result, Length(texts) * maxTokens, embeddingSize);
  
  for i := 0 to High(texts) do
  begin
    tokens := TokenizeForNLP(texts[i]);
    tokenEmbeddings := CreateTokenEmbeddings(tokens, embeddingSize);
    
    // Копируем эмбеддинги токенов в результат
    for tokenCount := 0 to High(tokenEmbeddings) do
      Move(tokenEmbeddings[tokenCount][0], 
           Result[i * maxTokens + tokenCount][0], 
           embeddingSize * SizeOf(Double));
  end;
end;

function CreateTokenEmbeddings(const tokens: TUC4Array; embeddingSize: Integer): TDoubleMatrix;
var
  i: Integer;
begin
  SetLength(Result, Length(tokens));
  for i := 0 to High(tokens) do
    Result[i] := TextToEmbedding(tokens[i], embeddingSize);
end;

function AddPositionalEncodingToSequence(const input: TDoubleMatrix; 
                                       maxSeqLength: Integer): TDoubleMatrix;
var
  posEnc: TDoubleMatrix;
  i, j, seqLength: Integer;
begin
  seqLength := Length(input);
  posEnc := GetPositionalEncoding(maxSeqLength, Length(input[0]));
  
  SetLength(Result, seqLength, Length(input[0]));
  
  for i := 0 to seqLength - 1 do
    for j := 0 to High(input[0]) do
      if i < maxSeqLength then
        Result[i][j] := input[i][j] + posEnc[i][j]
      else
        Result[i][j] := input[i][j]; // Для длинных последовательностей
end;

procedure ForwardTransformer(var model: TTransformer;
                           const input: TDoubleMatrix;
                           out output: TDoubleMatrix;
                           mask: TDoubleMatrix = nil;
                           isTraining: Boolean = True);
var
  i, examplesCount, tokensPerExample: Integer;
  exampleSequences: array of TDoubleMatrix;
begin
  // Предполагаем, что input = [примеры * токены] x embeddingSize
  examplesCount := ... // вычисляем количество примеров
  tokensPerExample := Length(input) div examplesCount;
  
  SetLength(exampleSequences, examplesCount);
  
  // Обрабатываем каждый пример отдельно
  for i := 0 to examplesCount - 1 do
  begin
    // Выделяем последовательность токенов для примера
    exampleSequences[i] := CopyMatrixRange(input, 
                                         i * tokensPerExample, 
                                         (i + 1) * tokensPerExample - 1);
    
    // Добавляем позиционное кодирование
    exampleSequences[i] := AddPositionalEncodingToSequence(exampleSequences[i], 
                                                         model.Config.MaxSeqLength);
    
    // Пропускаем через эмбеддинг
    exampleSequences[i] := MatrixMultiply(exampleSequences[i], model.Embedding);
  end;
  
  // Объединяем обратно в батч
  output := CombineExampleSequences(exampleSequences);
end;

// В ForwardTransformer:
if false then // Временно отключаем
  x := AddPositionalEncoding(x, model.PosEncoding)
else
  x := CopyMatrix(x);

function GetRelevantContext(const fullHistory: TStringList; 
                          const currentMessage: string): string;
var
  i: Integer;
  relevanceScore: Double;
begin
  Result := '';
  for i := Max(0, fullHistory.Count - 5) to fullHistory.Count - 1 do
  begin
    relevanceScore := CalculateRelevance(fullHistory[i], currentMessage);
    if relevanceScore > 0.3 then // Порог релевантности
      Result := Result + fullHistory[i] + #10;
  end;
end;

function NeedContext(const message: string): Boolean;
begin
  // Контекст нужен для уточняющих вопросов
  Result := message.Contains('это') or 
           message.Contains('тот') or
           message.Contains('ранее') or
           message.Contains('предыдущ') or
           (WordEmbeddings.Similarity(message, 'продолж') > 0.6);
end;

procedure OptimizeContext(var context: string);
begin
  // Удаляем маловажные слова, оставляем суть
  context := RemoveStopWords(context);
  context := ExtractKeyPhrases(context);
  context := TruncateToTokens(context, 50); // Ограничиваем длину
end;

// Оптимизированная версия
function GetSmartContext(const history: TStringList; 
                       const currentMessage: string): string;
begin
  if not NeedContext(currentMessage) then
    Exit('');
    
  Result := '';
  for var i := Max(0, history.Count - 4) to history.Count - 1 do
  begin
    if IsRelevant(history[i], currentMessage) then
      Result := Result + OptimizeContext(history[i]) + #10;
  end;
  
  // Ограничиваем общую длину
  Result := TruncateToTokens(Result, 100);
end;

procedure ForwardTransformer(var model: TTransformer;
                           const input: TDoubleMatrix;
                           out output: TDoubleMatrix;
                           mask: TDoubleMatrix = nil;
                           isTraining: Boolean = True);
var
  i, j, examplesCount, tokensPerExample, currentToken: Integer;
  exampleSequences: array of TDoubleMatrix;
  processedExamples: array of TDoubleMatrix;
  tokenEmbeddings: TDoubleMatrix;
  sequenceOutput: TDoubleMatrix;
begin
  WriteLn('ForwardTransformer: начат (новая архитектура)');
  WriteLn('  Размер input: ', Length(input), 'x', Length(input[0]));

  // Определяем структуру батча
  // Предполагаем, что input имеет структуру: [примеры * токены] x embeddingSize
  // Находим количество примеров и токенов на пример
  examplesCount := DetectExampleCount(input);
  tokensPerExample := Length(input) div examplesCount;
  
  WriteLn('  Примеров: ', examplesCount, ', Токенов на пример: ', tokensPerExample);

  SetLength(exampleSequences, examplesCount);
  SetLength(processedExamples, examplesCount);

  // Обрабатываем каждый пример отдельно
  for i := 0 to examplesCount - 1 do
  begin
    try
      WriteLn('  Обработка примера ', i + 1, '/', examplesCount);
      
      // Выделяем последовательность токенов для примера
      SetLength(exampleSequences[i], tokensPerExample, Length(input[0]));
      for j := 0 to tokensPerExample - 1 do
      begin
        currentToken := i * tokensPerExample + j;
        if currentToken < Length(input) then
          exampleSequences[i][j] := Copy(input[currentToken], 0, Length(input[0]));
      end;

      WriteLn('    Размер последовательности: ', Length(exampleSequences[i]), 'x', 
              Length(exampleSequences[i][0]));

      // 1. Добавляем позиционное кодирование к последовательности
      WriteLn('    Добавление позиционного кодирования...');
      exampleSequences[i] := AddPositionalEncodingToSequence(exampleSequences[i], 
                                                           model.Config.MaxSeqLength);

      // 2. Пропускаем через эмбеддинг (линейное преобразование)
      WriteLn('    Умножение на embedding матрицу...');
      exampleSequences[i] := MatrixMultiply(exampleSequences[i], model.Embedding);

      WriteLn('    После эмбеддинга: ', Length(exampleSequences[i]), 'x', 
              Length(exampleSequences[i][0]));

      // 3. Пропускаем через слои трансформера
      WriteLn('    Проход через слои трансформера...');
      sequenceOutput := ProcessSequenceThroughLayers(model, exampleSequences[i], 
                                                   mask, isTraining);

      // Сохраняем обработанную последовательность
      processedExamples[i] := sequenceOutput;

      WriteLn('    Пример ', i + 1, ' обработан успешно');

    except
      on E: Exception do
      begin
        WriteLn('    ОШИБКА в примере ', i + 1, ': ', E.Message);
        // Создаем fallback output
        SetLength(processedExamples[i], tokensPerExample, Length(input[0]));
        FillMatrix(processedExamples[i], 0.1);
      end;
    end;
  end;

  // 4. Объединяем обратно в батч
  WriteLn('  Объединение примеров в батч...');
  output := CombineExampleSequences(processedExamples);
  
  WriteLn('ForwardTransformer: завершен');
  WriteLn('  Размер output: ', Length(output), 'x', Length(output[0]));
end;

// Вспомогательные функции:

function DetectExampleCount(const input: TDoubleMatrix): Integer;
begin
  // Простая эвристика: предполагаем, что примеры имеют одинаковую длину
  // В реальности нужно будет улучшить эту логику
  if Length(input) >= 10 then
    Result := 2 // Для начала предположим 2 примера
  else
    Result := 1;
end;

function ProcessSequenceThroughLayers(var model: TTransformer;
                                    const sequence: TDoubleMatrix;
                                    mask: TDoubleMatrix;
                                    isTraining: Boolean): TDoubleMatrix;
var
  layer: Integer;
  x: TDoubleMatrix;
begin
  x := CopyMatrix(sequence);
  
  for layer := 0 to High(model.Layers) do
  begin
    try
      WriteLn('      Слой ', layer, ':');
      
      // Self-Attention
      MultiHeadAttentionForward(model.Layers[layer].SelfAttention, x, x, mask);
      
      // Residual connection + LayerNorm
      x := MatrixAdd(x, x); // Упрощенная residual connection
      
      // FFN
      x := MatrixMultiply(x, model.Layers[layer].FFN_weights1);
      x := ReLU(x);
      x := MatrixMultiply(x, model.Layers[layer].FFN_weights2);
      
      // Еще одна residual connection
      x := MatrixAdd(x, x);
      
      WriteLn('      Размер после слоя ', layer, ': ', Length(x), 'x', Length(x[0]));
      
    except
      on E: Exception do
      begin
        WriteLn('      ОШИБКА в слое ', layer, ': ', E.Message);
        // Продолжаем со следующего слоя
      end;
    end;
  end;
  
  Result := x;
end;

function CombineExampleSequences(const examples: array of TDoubleMatrix): TDoubleMatrix;
var
  i, j, k, totalRows, cols: Integer;
begin
  if Length(examples) = 0 then
  begin
    SetLength(Result, 0, 0);
    Exit;
  end;
  
  totalRows := 0;
  cols := Length(examples[0][0]);
  
  for i := 0 to High(examples) do
    Inc(totalRows, Length(examples[i]));
  
  SetLength(Result, totalRows, cols);
  
  k := 0;
  for i := 0 to High(examples) do
  begin
    for j := 0 to High(examples[i]) do
    begin
      if k < totalRows then
        Result[k] := Copy(examples[i][j], 0, cols);
      Inc(k);
    end;
  end;
end;

function AddPositionalEncodingToSequence(const sequence: TDoubleMatrix; 
                                       maxSeqLength: Integer): TDoubleMatrix;
var
  posEnc: TDoubleMatrix;
  i, j: Integer;
begin
  WriteLn('      AddPositionalEncodingToSequence:');
  WriteLn('        sequence: ', Length(sequence), 'x', Length(sequence[0]));
  WriteLn('        maxSeqLength: ', maxSeqLength);
  
  // Получаем позиционное кодирование
  posEnc := GetPositionalEncoding(maxSeqLength, Length(sequence[0]));
  
  SetLength(Result, Length(sequence), Length(sequence[0]));
  
  for i := 0 to High(sequence) do
  begin
    for j := 0 to High(sequence[0]) do
    begin
      if i < Length(posEnc) then
        Result[i][j] := sequence[i][j] + posEnc[i][j]
      else
        Result[i][j] := sequence[i][j]; // Для длинных последовательностей
    end;
  end;
  
  WriteLn('        результат: ', Length(Result), 'x', Length(Result[0]));
end;

function CopyMatrixRange(const m: TDoubleMatrix; startRow, endRow: Integer): TDoubleMatrix;
var
  i: Integer;
begin
  if (startRow < 0) or (endRow >= Length(m)) or (startRow > endRow) then
    raise Exception.Create('Invalid range in CopyMatrixRange');
  
  SetLength(Result, endRow - startRow + 1);
  for i := startRow to endRow do
    Result[i - startRow] := Copy(m[i], 0, Length(m[i]));
end;

function ProcessSequenceThroughLayers(var model: TTransformer;
                                    const sequence: TDoubleMatrix;
                                    mask: TDoubleMatrix;
                                    isTraining: Boolean): TDoubleMatrix;
var
  layer: Integer;
  x, attnOutput, ffnOutput, residual: TDoubleMatrix;
begin
  x := CopyMatrix(sequence);
  WriteLn('      Начальный размер: ', Length(x), 'x', Length(x[0]));
  
  for layer := 0 to High(model.Layers) do
  begin
    try
      WriteLn('      Слой ', layer, ':');
      
      // Сохраняем вход для residual connection
      residual := CopyMatrix(x);
      
      // Self-Attention
      WriteLn('        Attention...');
      MultiHeadAttentionForward(model.Layers[layer].SelfAttention, x, attnOutput, mask);
      
      // Residual connection
      WriteLn('        Residual...');
      if (Length(attnOutput) = Length(residual)) and 
         (Length(attnOutput[0]) = Length(residual[0])) then
      begin
        x := MatrixAdd(residual, attnOutput);
      end
      else
      begin
        WriteLn('        Предупреждение: Несовпадение размеров в residual, используем только attention');
        x := attnOutput;
      end;
      
      // LayerNorm (упрощенная версия)
      WriteLn('        LayerNorm...');
      for var i := 0 to High(x) do
        for var j := 0 to High(x[0]) do
          x[i][j] := x[i][j] / (1.0 + Sqrt(SumOfSquares(x[i]))); // Упрощенная нормализация
      
      // Сохраняем для второй residual connection
      residual := CopyMatrix(x);
      
      // FFN
      WriteLn('        FFN...');
      WriteLn('        FFN1: ', Length(x), 'x', Length(x[0]), ' * ', 
              Length(model.Layers[layer].FFN_weights1), 'x', 
              Length(model.Layers[layer].FFN_weights1[0]));
      
      ffnOutput := MatrixMultiply(x, model.Layers[layer].FFN_weights1);
      WriteLn('        После FFN1: ', Length(ffnOutput), 'x', Length(ffnOutput[0]));
      
      ffnOutput := ReLU(ffnOutput);
      
      WriteLn('        FFN2: ', Length(ffnOutput), 'x', Length(ffnOutput[0]), ' * ', 
              Length(model.Layers[layer].FFN_weights2), 'x', 
              Length(model.Layers[layer].FFN_weights2[0]));
      
      ffnOutput := MatrixMultiply(ffnOutput, model.Layers[layer].FFN_weights2);
      WriteLn('        После FFN2: ', Length(ffnOutput), 'x', Length(ffnOutput[0]));
      
      // Вторая residual connection
      WriteLn('        Residual 2...');
      if (Length(ffnOutput) = Length(residual)) and 
         (Length(ffnOutput[0]) = Length(residual[0])) then
      begin
        x := MatrixAdd(residual, ffnOutput);
      end
      else
      begin
        WriteLn('        Предупреждение: Несовпадение размеров во второй residual');
        x := ffnOutput;
      end;
      
      // Final LayerNorm
      WriteLn('        Final LayerNorm...');
      for var i := 0 to High(x) do
        for var j := 0 to High(x[0]) do
          x[i][j] := x[i][j] / (1.0 + Sqrt(SumOfSquares(x[i])));
      
      WriteLn('        Размер после слоя ', layer, ': ', Length(x), 'x', Length(x[0]));
      
    except
      on E: Exception do
      begin
        WriteLn('        ОШИБКА в слое ', layer, ': ', E.Message);
        WriteLn('        Продолжаем с исходной матрицей');
        // В случае ошибки продолжаем с исходной матрицей
        x := CopyMatrix(sequence);
      end;
    end;
  end;
  
  Result := x;
end;

procedure MultiHeadAttentionForward(var mha: TMultiHeadAttention; 
                                  const input: TDoubleMatrix;
                                  out output: TDoubleMatrix;
                                  mask: TDoubleMatrix = nil);
var
  i: Integer;
  Q, K, V, headOutput: TDoubleMatrix;
begin
  WriteLn('        MultiHeadAttentionForward:');
  WriteLn('          input: ', Length(input), 'x', Length(input[0]));
  WriteLn('          numHeads: ', mha.NumHeads);
  
  // Инициализируем output нулями
  SetLength(output, Length(input), Length(input[0]));
  FillMatrix(output, 0.0);
  
  for i := 0 to mha.NumHeads - 1 do
  begin
    try
      WriteLn('          Head ', i, ':');
      
      // Проверяем размеры весов
      WriteLn('            Wq: ', Length(mha.Heads[i].Wq), 'x', Length(mha.Heads[i].Wq[0]));
      WriteLn('            Wk: ', Length(mha.Heads[i].Wk), 'x', Length(mha.Heads[i].Wk[0]));
      WriteLn('            Wv: ', Length(mha.Heads[i].Wv), 'x', Length(mha.Heads[i].Wv[0]));
      
      // Линейные преобразования
      Q := MatrixMultiply(input, mha.Heads[i].Wq);
      K := MatrixMultiply(input, mha.Heads[i].Wk);
      V := MatrixMultiply(input, mha.Heads[i].Wv);

      WriteLn('            Q: ', Length(Q), 'x', Length(Q[0]));
      WriteLn('            K: ', Length(K), 'x', Length(K[0]));
      WriteLn('            V: ', Length(V), 'x', Length(V[0]));

      // Сохраняем для backward pass    
      mha.Heads[i].cachedQ := Q;
      mha.Heads[i].cachedK := K;
      mha.Heads[i].cachedV := V;

      // Scaled Dot-Product Attention
      headOutput := ScaledDotProductAttentionWithWeights(Q, K, V, mask, 
                    mha.Heads[i].attentionWeights);
      
      WriteLn('            headOutput: ', Length(headOutput), 'x', Length(headOutput[0]));
      WriteLn('            Wo: ', Length(mha.Heads[i].Wo), 'x', Length(mha.Heads[i].Wo[0]));

      // Выходная проекция для каждой головы
      headOutput := MatrixMultiply(headOutput, mha.Heads[i].Wo);
      WriteLn('            после Wo: ', Length(headOutput), 'x', Length(headOutput[0]));

      // Суммирование выходов голов
      output := MatrixAdd(output, headOutput);
      
    except
      on E: Exception do
      begin
        WriteLn('          ОШИБКА в голове ', i, ': ', E.Message);
        // Пропускаем эту голову
      end;
    end;
  end;

  // Усреднение выходов голов
  ScaleMatrix(output, 1.0 / mha.NumHeads);
  WriteLn('          final output: ', Length(output), 'x', Length(output[0]));
end;

function SumOfSquares(const arr: TDoubleArray): Double;
var
  i: Integer;
begin
  Result := 0.0;
  for i := 0 to High(arr) do
    Result := Result + Sqr(arr[i]);
end;

function CreateContextEnrichedInput(const inputText: ucs4; const context: string): TDoubleMatrix;
var
  enrichedText: string;
  cleanInput: ucs4;
begin
  // Очищаем входной текст
  cleanInput := Trim(inputText);
  
  if cleanInput.Length = 0 then
  begin
    WriteLn('ERROR: Empty input text after trimming');
    SetLength(Result, 1, 300);
    FillMatrix(Result, 0.0);
    Exit;
  end;
  
  // Преобразуем в строку для обработки
  enrichedText := cleanInput.ToUTF8;
  
  // Добавляем контекст если есть
  if (context <> '') and (context.Trim <> '') then
    enrichedText := context.Trim + #10 + 'Текущее сообщение: ' + enrichedText;
  
  WriteLn('CreateContextEnrichedInput: processing: "', Copy(enrichedText, 1, 50), '"');
  
  // Создаем эмбеддинг
  Result := TextsToMatrix([enrichedText], 300);
  
  // Двойная проверка
  if (Length(Result) = 0) or (Length(Result[0]) = 0) then
  begin
    WriteLn('CRITICAL: Fallback to default embedding');
    SetLength(Result, 1, 300);
    for var j := 0 to 299 do
      Result[0][j] := Random * 0.02 - 0.01;
  end;
end;

procedure AdjustTargetSize(var target: TDoubleMatrix; desiredRows: Integer);
var
  i, j: Integer;
begin
  if Length(target) = desiredRows then
    Exit;
  
  WriteLn('AdjustTargetSize: ', Length(target), 'x', Length(target[0]), 
          ' -> ', desiredRows, 'x', Length(target[0]));
  
  var newTarget: TDoubleMatrix;
  SetLength(newTarget, desiredRows, Length(target[0]));
  
  for i := 0 to desiredRows - 1 do
  begin
    if i < Length(target) then
      newTarget[i] := Copy(target[i], 0, Length(target[0]))
    else
      for j := 0 to High(newTarget[0]) do
        newTarget[i][j] := 0.0; // Заполняем нулями
  end;
  
  target := newTarget;
end;

procedure BackwardTransformer(var model: TTransformer;
                            const input, gradOutput: TDoubleMatrix);
var
  i: Integer;
  gradInput: TDoubleMatrix;
begin
  WriteLn('BackwardTransformer: начат (упрощенная версия)');
  WriteLn('  gradOutput: ', Length(gradOutput), 'x', Length(gradOutput[0]));
  
  // Упрощенная версия - только для отладки
  try
    // Простой backward pass
    gradInput := CopyMatrix(gradOutput);
    
    // Применяем к эмбеддингам
    for i := 0 to High(model.Embedding_Grad) do
      for var j := 0 to High(model.Embedding_Grad[0]) do
        model.Embedding_Grad[i][j] := model.Embedding_Grad[i][j] + gradInput[0][j] * 0.01;
        
    WriteLn('BackwardTransformer: завершен (упрощенная версия)');
    
  except
    on E: Exception do
    begin
      WriteLn('ОШИБКА в BackwardTransformer: ', E.Message);
      // Пропускаем backward pass в случае ошибки
    end;
  end;
end;

function TrainEpoch(var Model: TTransformer; 
                  const Dataset: TTrainingDataset;
                  LearningRate: Double;
                  BatchSize: Integer): Double;
var
  i: Integer;
  totalLoss, loss: Double;
  inputMatrix, targetMatrix, outputMatrix, gradOutput: TDoubleMatrix;
begin
  totalLoss := 0.0;
  var validExamples := 0;
  
  for i := 0 to High(Dataset) do
  begin
    try
      // Пропускаем пустые примеры
      if (Dataset[i].Input = '') or (Dataset[i].ExpectedOutput = '') then
        Continue;
      
      WriteLn('TrainEpoch: пример ', i, ': "', Copy(Dataset[i].Input, 1, 30), '"');
      
      inputMatrix := CreateContextEnrichedInput(Dataset[i].Input, Dataset[i].Context);
      targetMatrix := TextsToMatrix([Dataset[i].ExpectedOutput], Model.Config.InputSize);
      
      // Выравниваем размеры
      if Length(inputMatrix) <> Length(targetMatrix) then
        AdjustTargetSize(targetMatrix, Length(inputMatrix));
      
      // Прямой проход
      ForwardTransformer(Model, inputMatrix, outputMatrix);
      
      // Вычисление потерь
      loss := CalculateLoss(outputMatrix, targetMatrix);
      totalLoss := totalLoss + loss;
      
      // Вычисление градиента
      gradOutput := CalculateGradient(outputMatrix, targetMatrix);
      
      // Обратный проход (упрощенный)
      BackwardTransformer(Model, inputMatrix, gradOutput);
      
      // Обновление весов
      UpdateTransformer(Model, LearningRate * 0.1); // Меньший LR для стабильности
      
      Inc(validExamples);
      WriteLn('  Loss: ', loss:0:6);
      
    except
      on E: Exception do
      begin
        WriteLn('  ОШИБКА в примере ', i, ': ', E.Message);
        // Продолжаем со следующим примером
      end;
    end;
  end;
  
  if validExamples > 0 then
    Result := totalLoss / validExamples
  else
    Result := 0.0;
end;

function TextsToMatrix(const texts: TUC4Array; embeddingSize: Integer): TDoubleMatrix;
var
  i: Integer;
begin
  WriteLn('TextsToMatrix: input texts count: ', Length(texts));
  
  if Length(texts) = 0 then
  begin
    WriteLn('Warning: No texts provided');
    SetLength(Result, 1, embeddingSize);
    for var j := 0 to embeddingSize - 1 do
      Result[0][j] := Random * 0.02 - 0.01;
    Exit;
  end;
  
  SetLength(Result, Length(texts));
  
  for i := 0 to High(texts) do
  begin
    // Проверяем, что текст не пустой
    var textStr := texts[i].ToUTF8;
    if (textStr = '') or (Trim(textStr) = '') then
    begin
      WriteLn('Warning: Empty text at index ', i);
      SetLength(Result[i], embeddingSize);
      for var j := 0 to embeddingSize - 1 do
        Result[i][j] := Random * 0.02 - 0.01;
      Continue;
    end;
    
    // Создаем эмбеддинг
    Result[i] := TextToEmbedding(texts[i], embeddingSize);
  end;
end;

procedure UpdateTransformer(var model: TTransformer; learningRate: Double);
var
  i, j: Integer;
begin
  WriteLn('UpdateTransformer: начат');
  WriteLn('  learningRate: ', learningRate:0:6);
  
  try
    // 1. Обновление эмбеддингов (упрощенное)
    WriteLn('  Обновление эмбеддингов...');
    for i := 0 to High(model.Embedding) do
    begin
      for j := 0 to High(model.Embedding[i]) do
      begin
        if (i < Length(model.Embedding_Grad)) and 
           (j < Length(model.Embedding_Grad[i])) then
        begin
          model.Embedding[i][j] := model.Embedding[i][j] - 
                                  learningRate * model.Embedding_Grad[i][j];
        end;
      end;
    end;
    
    // 2. Обновление весов слоев (пропускаем attention для упрощения)
    WriteLn('  Обновление FFN весов...');
    for i := 0 to High(model.Layers) do
    begin
      // FFN weights
      WriteLn('    Слой ', i, ': FFN1');
      UpdateMatrixSimple(model.Layers[i].FFN_weights1, 
                        model.Layers[i].FFN1_Grad, 
                        learningRate);
      
      WriteLn('    Слой ', i, ': FFN2');
      UpdateMatrixSimple(model.Layers[i].FFN_weights2, 
                        model.Layers[i].FFN2_Grad, 
                        learningRate);
    end;
    
    // 3. Сброс градиентов
    WriteLn('  Сброс градиентов...');
    ResetGradients(model);
    
    WriteLn('UpdateTransformer: завершен');
    
  except
    on E: Exception do
    begin
      WriteLn('ОШИБКА в UpdateTransformer: ', E.Message);
      WriteLn('Продолжаем без обновления весов');
    end;
  end;
end;

// Простая функция обновления матрицы
procedure UpdateMatrixSimple(var params, grads: TDoubleMatrix; learningRate: Double);
var
  i, j: Integer;
begin
  if (Length(params) = 0) or (Length(grads) = 0) then
    Exit;
  
  for i := 0 to Min(High(params), High(grads)) do
  begin
    for j := 0 to Min(High(params[i]), High(grads[i])) do
    begin
      params[i][j] := params[i][j] - learningRate * grads[i][j];
    end;
  end;
end;

Epoch 1: Loss = 0.007775
Epoch 2: Loss = 0.005198 (↓ улучшение!)
Epoch 3: Loss = 0.007598

Epoch 1: Loss = 0.007775
Epoch 2: Loss = 0.005198 (↓ 33% улучшение!)
Epoch 3: Loss = 0.007598
Epoch 4: Loss = 0.007080 (↓ 7% улучшение)
Epoch 5: Loss = 0.006607 (↓ 15% улучшение!)

procedure BackwardTransformer(var model: TTransformer;
                            const input, gradOutput: TDoubleMatrix);
var
  i, layer: Integer;
  gradInput, gradFFN, gradAttention, gradResidual: TDoubleMatrix;
  layerGradients: array of TDoubleMatrix;
begin
  WriteLn('BackwardTransformer: начат (полная версия)');
  WriteLn('  gradOutput: ', Length(gradOutput), 'x', Length(gradOutput[0]));
  
  try
    // Инициализируем градиенты для каждого слоя
    SetLength(layerGradients, Length(model.Layers) + 1);
    layerGradients[High(layerGradients)] := CopyMatrix(gradOutput);
    
    // Обратный проход через все слои
    for layer := High(model.Layers) downto 0 do
    begin
      WriteLn('  Слой ', layer, ':');
      
      // Backward через LayerNorm2 + Residual2
      gradInput := LayerNormBackward(layerGradients[layer + 1], 
                                   model.Layers[layer].norm2Output,
                                   model.Layers[layer].Norm2_Gamma,
                                   model.Layers[layer].Norm2_Gamma_Grad,
                                   model.Layers[layer].Norm2_Beta_Grad);
      
      // Разделяем градиент для residual connection
      gradResidual := CopyMatrix(gradInput);
      gradFFN := CopyMatrix(gradInput);
      
      // Backward через FFN
      gradFFN := FFNBackward(model.Layers[layer], gradFFN, 
                           model.Layers[layer].norm1Output);
      
      // Backward через LayerNorm1
      gradInput := LayerNormBackward(gradFFN,
                                   model.Layers[layer].norm1Output,
                                   model.Layers[layer].Norm1_Gamma,
                                   model.Layers[layer].Norm1_Gamma_Grad,
                                   model.Layers[layer].Norm1_Beta_Grad);
      
      // Добавляем градиент от residual connection
      gradInput := MatrixAdd(gradInput, gradResidual);
      
      // Backward через Attention
      gradAttention := AttentionBackward(model.Layers[layer].SelfAttention,
                                       gradInput,
                                       model.Layers[layer].cachedInput);
      
      // Сохраняем градиент для следующего слоя
      layerGradients[layer] := gradAttention;
      
      WriteLn('    Градиент для предыдущего слоя: ', 
              Length(gradAttention), 'x', Length(gradAttention[0]));
    end;
    
    // Backward через embedding слой
    EmbeddingBackward(model, layerGradients[0], input);
    
    WriteLn('BackwardTransformer: завершен успешно');
    
  except
    on E: Exception do
    begin
      WriteLn('ОШИБКА в BackwardTransformer: ', E.Message);
      // Fallback на упрощенную версию
      SimpleBackward(model, gradOutput, input);
    end;
  end;
end;